[None][chore] load models lazily - #17281

#!/bin/bash
# Description: Compare `@register_auto_model` architectures with MODEL_ARCH_TO_MODULE.
set -uo pipefail

python - <<'PY'
import pathlib, re, ast

root = pathlib.Path("tensorrt_llm/_torch/models")
index_src = (root / "_arch_index.py").read_text()
tree = ast.parse(index_src)
tables = {}
for node in tree.body:
    if isinstance(node, ast.Assign) and isinstance(node.targets[0], ast.Name):
        try:
            tables[node.targets[0].id] = ast.literal_eval(node.value)
        except ValueError:
            pass
arch_index = tables.get("MODEL_ARCH_TO_MODULE", {})

decorated = {}
pat = re.compile(r'`@register_auto_model`\(\s*["\']([^"\']+)["\']')
for path in sorted(root.rglob("modeling_*.py")):
    for arch in pat.findall(path.read_text()):
        decorated.setdefault(arch, set()).add(path.stem)

missing = sorted(a for a in decorated if a not in arch_index)
extra = sorted(a for a in arch_index if a not in decorated)
wrong = sorted(
    (a, arch_index[a], sorted(mods))
    for a, mods in decorated.items()
    if a in arch_index and arch_index[a] not in mods
)
print("registered but MISSING from MODEL_ARCH_TO_MODULE:", missing)
print("in MODEL_ARCH_TO_MODULE but NOT registered:", extra)
print("mapped to the WRONG module:", wrong)
PY

#!/bin/bash
set -euo pipefail

root="tensorrt_llm/_torch/models"

printf '%s\n' '--- index and registration references ---'
rg -n -C 4 'MODEL_ARCH_TO_MODULE|ensure_model_registered|register_auto_model|LlavaLlamaModel|PixtralVisionModel' "$root" \
  -g '*.py'

printf '%s\n' '--- candidate module outlines ---'
for file in "$root"/_arch_index.py "$root"/modeling_vila.py "$root"/modeling_pixtral.py; do
  if [ -f "$file" ]; then
    echo "### $file"
    ast-grep outline "$file"
  fi
done

printf '%s\n' '--- index module existence ---'
python3 - <<'PY'
import ast
import pathlib

root = pathlib.Path("tensorrt_llm/_torch/models")
tree = ast.parse((root / "_arch_index.py").read_text())
table = next(
    node.value
    for node in tree.body
    if isinstance(node, ast.Assign)
    and any(isinstance(target, ast.Name) and target.id == "MODEL_ARCH_TO_MODULE"
            for target in node.targets)
)
mapping = ast.literal_eval(table)
for architecture, module in mapping.items():
    path = root / f"{module}.py"
    print(f"{architecture}: {module}.py {'OK' if path.is_file() else 'MISSING'}")
PY

#!/bin/bash
set -euo pipefail

root="tensorrt_llm/_torch/models"

printf '%s\n' '--- relevant lazy-loading code ---'
rg -n -C 8 'def ensure_model_registered|def register_auto_model|MODEL_ARCH_TO_MODULE|import_module' \
  "$root/_arch_index.py" "$root/modeling_auto.py" "$root/modeling_utils.py"

printf '%s\n' '--- non-literal registration sites for indexed architectures ---'
rg -n -C 3 'LlavaLlamaModel|PixtralVisionModel|model_architecture|register_auto_model' \
  "$root/modeling_vila.py" "$root/modeling_pixtral.py" "$root/modeling_mistral.py"

printf '%s\n' '--- AST comparison, including constant expressions ---'
python3 - <<'PY'
import ast
import pathlib

root = pathlib.Path("tensorrt_llm/_torch/models")
index_tree = ast.parse((root / "_arch_index.py").read_text())
index_node = next(
    node.value for node in index_tree.body
    if isinstance(node, ast.Assign)
    and any(isinstance(target, ast.Name)
            and target.id == "MODEL_ARCH_TO_MODULE"
            for target in node.targets)
)
index = ast.literal_eval(index_node)

registrations = {}
for path in sorted(root.glob("modeling_*.py")):
    tree = ast.parse(path.read_text())
    constants = {
        node.targets[0].id: ast.literal_eval(node.value)
        for node in tree.body
        if isinstance(node, ast.Assign)
        and len(node.targets) == 1
        and isinstance(node.targets[0], ast.Name)
        and isinstance(node.value, ast.Constant)
        and isinstance(node.value.value, str)
    }
    for node in ast.walk(tree):
        if not isinstance(node, ast.Call):
            continue
        func = node.func
        if not (isinstance(func, ast.Name) and func.id == "register_auto_model"):
            continue
        if len(node.args) != 1:
            continue
        arg = node.args[0]
        value = None
        if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
            value = arg.value
        elif (isinstance(arg, ast.Attribute)
              and isinstance(arg.value, ast.Name)
              and arg.value.id in constants
              and arg.attr == "model_architecture"):
            value = constants[arg.value.id]
        if value is not None:
            registrations.setdefault(value, set()).add(path.stem)

missing = sorted(set(registrations) - set(index))
extra = sorted(set(index) - set(registrations))
wrong = sorted(
    (arch, index[arch], sorted(registrations[arch]))
    for arch in sorted(set(index) & set(registrations))
    if index[arch] not in registrations[arch]
)
print("registered but missing:", missing)
print("indexed but not found by AST scan:", extra)
print("mapped to a different module:", wrong)
for arch in ("LlavaLlamaModel", "PixtralVisionModel"):
    print(f"{arch}: registered in {sorted(registrations.get(arch, ()))}, "
          f"indexed as {index.get(arch)!r}")
PY

#!/bin/bash
set -euo pipefail

root="tensorrt_llm/_torch/models"

python3 - <<'PY'
import pathlib
import re

root = pathlib.Path("tensorrt_llm/_torch/models")

index = {}
entry = re.compile(r'^\s*"([^"]+)":\s*"([^"]+)",\s*$')
for line in (root / "_arch_index.py").read_text().splitlines():
    match = entry.match(line)
    if match:
        index[match.group(1)] = match.group(2)

registrations = {}
unresolved = []
decorator = re.compile(
    r'^\s*@(?:[\w.]+\.)?register_auto_model\(\s*([^)]*?)\s*\)\s*$'
)
literal = re.compile(r"""^["']([^"']+)["']$""")
attribute = re.compile(r'^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$')

for path in sorted(root.glob("modeling_*.py")):
    lines = path.read_text().splitlines()
    constants = {}
    for line in lines:
        match = re.match(
            r'^\s*(\w+)\s*=\s*["\']([^"\']+)["\']\s*$', line
        )
        if match:
            constants[match.group(1)] = match.group(2)
        match = re.match(
            r'^\s*model_architecture\s*=\s*["\']([^"\']+)["\']\s*$', line
        )
        if match:
            constants["model_architecture"] = match.group(1)

    for line_number, line in enumerate(lines, 1):
        match = decorator.match(line)
        if not match:
            continue
        argument = match.group(1).strip()
        literal_match = literal.match(argument)
        if literal_match:
            architecture = literal_match.group(1)
        else:
            attribute_match = attribute.match(argument)
            architecture = (
                constants.get(attribute_match.group(2))
                if attribute_match and attribute_match.group(1) == "VilaConfig"
                else None
            )
        if architecture is None:
            unresolved.append(f"{path}:{line_number}: {argument}")
        else:
            registrations.setdefault(architecture, set()).add(path.stem)

missing = sorted(set(registrations) - set(index))
extra = sorted(set(index) - set(registrations))
wrong = sorted(
    (architecture, index[architecture], sorted(registrations[architecture]))
    for architecture in sorted(set(index) & set(registrations))
    if index[architecture] not in registrations[architecture]
)

print("registered but missing:", missing)
print("indexed but not registered:", extra)
print("mapped to a different module:", wrong)
print("unresolved decorators:", unresolved)
print("LlavaLlamaModel:", sorted(registrations.get("LlavaLlamaModel", ())))
print("PixtralVisionModel:", sorted(registrations.get("PixtralVisionModel", ())))
PY

#!/bin/bash
set -euo pipefail

file="tensorrt_llm/_torch/models/_arch_index.py"

sed -n '1,220p' "$file"

python3 - <<'PY'
import pathlib
import re

root = pathlib.Path("tensorrt_llm/_torch/models")
text = (root / "_arch_index.py").read_text()
match = re.search(
    r"MODEL_ARCH_TO_MODULE\s*=\s*\{(?P<body>.*?)\n\}",
    text,
    re.S,
)
if not match:
    raise SystemExit("MODEL_ARCH_TO_MODULE block not found")

index = dict(re.findall(
    r'^\s*"([^"]+)":\s*"([^"]+)",\s*$',
    match.group("body"),
    re.M,
))

registrations = {}
unresolved = []
decorator = re.compile(
    r'^\s*@(?:[\w.]+\.)?register_auto_model\(\s*([^)]*?)\s*\)\s*$'
)
literal = re.compile(r"""^["']([^"']+)["']$""")
attribute = re.compile(r'^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$')

for path in sorted(root.glob("modeling_*.py")):
    lines = path.read_text().splitlines()
    class_attributes = {}
    current_class = None
    for line in lines:
        class_match = re.match(r'^\s*class\s+(\w+)', line)
        if class_match:
            current_class = class_match.group(1)
        attr_match = re.match(
            r'^\s*model_architecture\s*=\s*["\']([^"\']+)["\']\s*$',
            line,
        )
        if attr_match and current_class:
            class_attributes[current_class] = attr_match.group(1)

    for line_number, line in enumerate(lines, 1):
        match = decorator.match(line)
        if not match:
            continue
        argument = match.group(1).strip()
        literal_match = literal.match(argument)
        if literal_match:
            architecture = literal_match.group(1)
        else:
            attribute_match = attribute.match(argument)
            architecture = (
                class_attributes.get(attribute_match.group(1))
                if attribute_match else None
            )
        if architecture is None:
            unresolved.append(f"{path}:{line_number}: {argument}")
        else:
            registrations.setdefault(architecture, set()).add(path.stem)

print("registered but missing:", sorted(set(registrations) - set(index)))
print("indexed but not registered:", sorted(set(index) - set(registrations)))
print("mapped to a different module:", sorted(
    (architecture, index[architecture], sorted(registrations[architecture]))
    for architecture in sorted(set(index) & set(registrations))
    if index[architecture] not in registrations[architecture]
))
print("unresolved decorators:", unresolved)
PY

#!/bin/bash
set -euo pipefail

ast-grep outline tests/unittest/llmapi/test_config_database.py \
  --items all --type function

rg -n -C 3 \
  'get_registered_model_class|_get_default_values_for_config|model_defaults' \
  tests/unittest/llmapi/test_config_database.py

(fd -t f -e yml -e yaml . tests/integration/test_lists || true) |
while IFS= read -r list_file; do
  rg -n -C 2 'test_config_database|llmapi' "$list_file" || true
done

#!/bin/bash
set -euo pipefail

printf '%s\n' '--- diff ---'
git diff -- tests/unittest/llmapi/test_config_database.py

printf '%s\n' '--- file header and helper ---'
sed -n '1,125p' tests/unittest/llmapi/test_config_database.py

printf '%s\n' '--- matching test-list entries with file names ---'
while IFS= read -r list_file; do
  matches=$(rg -n '(^|/)(test_config_database\.py|test_config_database)(:| |$)' "$list_file" || true)
  if [ -n "$matches" ]; then
    printf '%s\n%s\n' "$list_file" "$matches"
  fi
done < <(fd -t f -e yml -e yaml . tests/integration/test_lists)

#!/bin/bash
set -euo pipefail

printf '%s\n' '--- matching test-list entries ---'
find tests/integration/test_lists -type f \( -name '*.yml' -o -name '*.yaml' \) -print0 |
while IFS= read -r -d '' list_file; do
  if rg -n '(^|/)(test_config_database\.py|test_config_database)(:| |$)' "$list_file"; then
    printf 'FILE: %s\n' "$list_file"
  fi
done

printf '%s\n' '--- helper call sites ---'
rg -n -C 4 '_get_default_values_for_config|test_database_yaml_config_does_not_set_default_leaves' \
  tests/unittest/llmapi/test_config_database.py

printf '%s\n' '--- registry definitions and call sites ---'
rg -n -C 5 'def get_registered_model_class|MODEL.*REGISTR|register.*model|import.*model' \
  tensorrt_llm/_torch/models tensorrt_llm/_torch/models/modeling_utils.py

#!/bin/bash
set -euo pipefail

printf '%s\n' '--- custom model defaults ---'
rg -n -C 4 'def get_model_defaults|get_model_defaults\s*=|get_model_defaults\(' \
  tensorrt_llm/_torch/models --glob '*.py'

printf '%s\n' '--- lookup architectures and models ---'
rg -n '^[[:space:]]*(model|arch|config_path):' examples/configs/database/lookup.yaml \
  examples/configs/curated/lookup.yaml | head -160

printf '%s\n' '--- architecture index entries for custom-default classes ---'
rg -n -C 2 'MODEL_ARCH_TO_MODULE|MODEL_CLASS_TO_MODULE|Deepseek|Qwen|Llama|Whisper|Gemma|Phi|Mistral' \
  tensorrt_llm/_torch/models/_arch_index.py | head -240

printf '%s\n' '--- test module imports of model providers ---'
rg -n '^import |^from ' tests/unittest/llmapi/test_config_database.py \
  | rg 'model|torch|tensorrt_llm' || true

python3 - <<'PY'
import ast
from pathlib import Path

test_path = Path("tests/unittest/llmapi/test_config_database.py")
source = test_path.read_text(encoding="utf-8")
tree = ast.parse(source)

functions = {
    node.name: node
    for node in ast.walk(tree)
    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
}
helper = functions["_get_default_values_for_config"]
coverage_test = functions["test_database_yaml_config_does_not_set_default_leaves"]

helper_calls_resolver = any(
    isinstance(node, ast.Call)
    and isinstance(node.func, ast.Name)
    and node.func.id == "get_registered_model_class"
    for node in ast.walk(helper)
)
coverage_test_calls_helper = any(
    isinstance(node, ast.Call)
    and isinstance(node.func, ast.Name)
    and node.func.id == "_get_default_values_for_config"
    for node in ast.walk(coverage_test)
)
provider_imported_by_test = "modeling_deepseekv4" in source

lookup = Path("examples/configs/curated/lookup.yaml").read_text(encoding="utf-8")
provider = Path("tensorrt_llm/_torch/models/modeling_deepseekv4.py").read_text(
    encoding="utf-8"
)
arch_index = Path("tensorrt_llm/_torch/models/_arch_index.py").read_text(
    encoding="utf-8"
)

print(f"helper_calls_get_registered_model_class={helper_calls_resolver}")
print(f"parametrized_test_calls_helper={coverage_test_calls_helper}")
print(f"lookup_contains_DeepseekV4ForCausalLM={'DeepseekV4ForCausalLM' in lookup}")
print(f"provider_defines_get_model_defaults={'def get_model_defaults' in provider}")
print(
    "arch_index_maps_DeepseekV4ForCausalLM="
    f"{'\"DeepseekV4ForCausalLM\": \"modeling_deepseekv4\"' in arch_index}"
)
print(f"test_directly_imports_modeling_deepseekv4={provider_imported_by_test}")

assert helper_calls_resolver
assert coverage_test_calls_helper
assert "DeepseekV4ForCausalLM" in lookup
assert "def get_model_defaults" in provider
assert '"DeepseekV4ForCausalLM": "modeling_deepseekv4"' in arch_index
assert not provider_imported_by_test
PY

python3 - <<'PY'
import ast
from pathlib import Path

test_path = Path("tests/unittest/llmapi/test_config_database.py")
source = test_path.read_text(encoding="utf-8")
tree = ast.parse(source)

functions = {
    node.name: node
    for node in ast.walk(tree)
    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
}
helper = functions["_get_default_values_for_config"]
coverage_test = functions["test_database_yaml_config_does_not_set_default_leaves"]

helper_calls_resolver = any(
    isinstance(node, ast.Call)
    and isinstance(node.func, ast.Name)
    and node.func.id == "get_registered_model_class"
    for node in ast.walk(helper)
)
coverage_test_calls_helper = any(
    isinstance(node, ast.Call)
    and isinstance(node.func, ast.Name)
    and node.func.id == "_get_default_values_for_config"
    for node in ast.walk(coverage_test)
)
provider_imported_by_test = "modeling_deepseekv4" in source

lookup = Path("examples/configs/curated/lookup.yaml").read_text(encoding="utf-8")
provider = Path("tensorrt_llm/_torch/models/modeling_deepseekv4.py").read_text(
    encoding="utf-8"
)
arch_index = Path("tensorrt_llm/_torch/models/_arch_index.py").read_text(
    encoding="utf-8"
)
deepseek_arch_entry = '"DeepseekV4ForCausalLM": "modeling_deepseekv4"'

print(f"helper_calls_get_registered_model_class={helper_calls_resolver}")
print(f"parametrized_test_calls_helper={coverage_test_calls_helper}")
print(f"lookup_contains_DeepseekV4ForCausalLM={'DeepseekV4ForCausalLM' in lookup}")
print(f"provider_defines_get_model_defaults={'def get_model_defaults' in provider}")
print(f"arch_index_maps_DeepseekV4ForCausalLM={deepseek_arch_entry in arch_index}")
print(f"test_directly_imports_modeling_deepseekv4={provider_imported_by_test}")

assert helper_calls_resolver
assert coverage_test_calls_helper
assert "DeepseekV4ForCausalLM" in lookup
assert "def get_model_defaults" in provider
assert deepseek_arch_entry in arch_index
assert not provider_imported_by_test
PY

#!/bin/bash
set -euo pipefail

printf '%s\n' '--- test-db list files ---'
find tests/integration/test_lists -type f -path '*test-db*' \
  \( -name '*.yml' -o -name '*.yaml' \) -print | sort

printf '%s\n' '--- qa list files ---'
find tests/integration/test_lists -type f -path '*qa*' \
  \( -name '*.yml' -o -name '*.yaml' \) -print | sort

printf '%s\n' '--- list files containing the llmapi unittest group ---'
find tests/integration/test_lists -type f \
  \( -name '*.yml' -o -name '*.yaml' \) -print0 |
while IFS= read -r -d '' list_file; do
  if rg -q 'unittest/llmapi/' "$list_file"; then
    printf '%s\n' "$list_file"
  fi
done | sort

#!/bin/bash
set -euo pipefail

fd -t f . tests/integration/test_lists | sort
rg -n -C 2 'test_lazy_model_zoo|test_trtllm_serve_endpoints' \
  tests/integration/test_lists || true

git status --short
git diff --stat -- tests/unittest/others/test_lazy_model_zoo.py tests/unittest/_torch/visual_gen/test_trtllm_serve_endpoints.py
git diff --unified=3 -- tests/unittest/others/test_lazy_model_zoo.py tests/unittest/_torch/visual_gen/test_trtllm_serve_endpoints.py
rg -n 'unittest/others|test_lazy_model_zoo|test_trtllm_serve_endpoints' tests/integration/test_lists